home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1999 January - Disc 2 / Macworld (1999-01) (Disk 2).dmg / Serious Demos / Symbolic Composer 4.2 / Environment / Projects / Neurons / Oscillating Neurons < prev    next >
Lisp/Scheme  |  1998-10-26  |  7KB  |  212 lines
  1. ; Constructing Self-Oscillating Parallel Neurons
  2.  
  3. ; Notes: This file implements a general way to feedback 
  4. ; neurons and implement custom sequences the neurons
  5. ; can both recognise and fire. Examples on constructing
  6. ; parallel neural patterns are also shown here.
  7.  
  8. ; Use melody,1 melody2 and melody3 to define instrument symbols.
  9.  
  10. #| Oscillation Rules
  11.  
  12. How to make a neuron which survises multiple oscillations?
  13. Self-oscillating neuron resembles oscillators build with 
  14. electronic components. But as there are design principles
  15. for electronic oscillators there exist no rules for building
  16. neural oscillators.
  17.  
  18. For this reason only some very general rules can be given, 
  19. which will maximize the possibility to create self-oscillating 
  20. neurons. The rest lies on your experimentations. Discovering
  21. self-oscillating neurons is like modelling the reticular
  22. activation center in the brain, which is used to control the
  23. wake/sleep activity. In at least a theoretical sense this
  24. device resembles a self-oscillating neuron, which feeds it
  25. output to all cortical areas, orchestrating them all to
  26. operate in a certain way, which will result 'consiciousness'.
  27. Succesful experimenting!
  28.  
  29. Rule1:
  30. To prevent the neuron from stucking add noise to input patterns.
  31. This makes is sure that the neuron input will never be the
  32. same, and hence no loops will be formed.
  33.  
  34. Rule2: 
  35. Make the neuron fire symbols in range that the input rules
  36. can recognise. If the output symbols are in different range
  37. then rules cannot find any patterns to fire, and the otherwise
  38. option is used. To maximise feedback properties scale the
  39. otherwise output to a range the rules can handle. This ables
  40. the rules to recognise it in the next oscillation.
  41. |#
  42.  
  43. ; Define two extension functions, one for feedbacking neurons
  44. ; and another to fire given sequences within neurons.
  45.  
  46. (defun feedback-neuron (name n inputs)
  47.   (let ((out nil) (collect nil))
  48.     (dotimes (i n)
  49.       (setq out (apply 'run-neuron (append (list name) inputs)))
  50.       (push out collect)
  51.       (setq inputs (append (cdr inputs) (list out))))
  52.     (nreverse collect)))
  53.  
  54. (defun pack-name (a b)
  55.   (compress (append (explode a) '(-) (explode b))))
  56.  
  57. (defun fire (&optional name sequence)
  58.   (let ((out nil)
  59.         (counter nil))
  60.     (cond (sequence
  61.            (cond ((equal sequence :reset)
  62.                   (set (pack-name 'counter name) 0))
  63.                  (t (set (pack-name 'seq name) (vector-to-list sequence))
  64.                     (set (pack-name 'counter name) 0)))
  65.            t)
  66.           (t (setq counter (eval (pack-name 'counter name)))
  67.              (setq out (nth (mod counter (length (eval (pack-name 'seq name)))) 
  68.                             (eval (pack-name 'seq name))))
  69.              (setq counter (1+ counter))
  70.              (set (pack-name 'counter name) counter)
  71.              out))))
  72.     
  73. ; Define 3 fibonacci sequences.
  74.  
  75. (fire 'fibonacci-seq1 (gen-fibonacci 6 'a 'b))
  76. (fire 'fibonacci-seq2 (gen-fibonacci 6 '-b '-c))
  77. (fire 'fibonacci-seq3 (gen-fibonacci 6 'b 'a))
  78.  
  79. ; Define a neuron that fires fibonacci rules.
  80. ; Use this as a  template for further modifications when 
  81. ; building oscillating neurons.
  82.  
  83. (def-neuron fibonacci-rule
  84.   (in 1 'a) (fire 'fibonacci-seq1)
  85.   (in 1 'b) (fire 'fibonacci-seq2)
  86.   (otherwise (pick-random '(a b)))
  87. )
  88.  
  89. ; Examine the following in the visualizer. There are interesting
  90. ; repetitions within the melody1 pattern. The melody1 pattern
  91. ; lenght is determined by the input pattern (a b c), and the
  92. ; the number of feedbacks (here 60). Experiment with different
  93. ; values.
  94.  
  95. (setq melody1
  96.       (flatten
  97.        (feedback-neuron 'fibonacci-rule 60 '((a b c)))))
  98.  
  99. ; Building 2nd melody line
  100.  
  101. ; If you need more melody lines here is an example based on
  102. ; recognising fibonacci sequences. If the fibonacci sequence
  103. ; is found then the input pattern is shifted by 10, otherwise
  104. ; it is shifted by 5, and an output pattern is formed.
  105.  
  106. (def-neuron fibonacci-modifier
  107.   (in 1 (fire 'fibonacci-seq1)) (in 1 10)
  108.   (otherwise (in 1 5))
  109. )
  110.  
  111. ; reset fibonacci-seq before calculation
  112.  
  113. (fire 'fibonacci-seq1 :reset)
  114.  
  115. ; build 2nd melody
  116.  
  117. (setq melody2 (run-neuron 'fibonacci-modifier melody1))
  118.  
  119. ; Building 3rd melody line
  120.  
  121. ; Here the 3rd melody line is calculated by finding a fibonacci
  122. ; sequence from input line 1, and a reversed fibonacci sequence
  123. ; from input line 2, and if both are found then the input line 1 
  124. ; is shifted -3 to form the output, otherwise input line 2 is 
  125. ; shifted by 3 to form the output.
  126.  
  127. (def-neuron fibonacci-comparator
  128.   (and (in 1 (fire 'fibonacci-seq1))
  129.        (in 2 (fire 'fibonacci-seq3))) (in 1 -3)
  130.   (otherwise (in 2 3))
  131. )
  132.  
  133. ; reset sequences
  134.  
  135. (fire 'fibonacci-seq1 :reset)
  136. (fire 'fibonacci-seq3 :reset)
  137.  
  138. ; make the 3rd melody line comparing melody1 and melody3
  139.  
  140. (setq melody3 (run-neuron 'fibonacci-comparator melody1 melody2))
  141.  
  142. ; Additional Feedback
  143.  
  144. ; The following seems to be able to produce further oscillations
  145. ; based on the melody1, melody2 and melody3. When examined in
  146. ; visualizer you notice a segment (size melody1) which repeats
  147. ; but is never quite same. The auditive could be interesting
  148. ; because these sequences should be able to be recognisable in
  149. ; auditive form, but each one is still different.
  150.  
  151. ; reset sequences
  152.  
  153. (fire 'fibonacci-seq1 :reset)
  154. (fire 'fibonacci-seq3 :reset)
  155.  
  156. ; generate melody (may take some time...)
  157.  
  158. (setq mel
  159.   (flatten
  160.      (feedback-neuron 'fibonacci-comparator 4 (list melody1 melody2 melody3))))
  161.  
  162.  
  163. #| How feedback-neuron operates?
  164.  
  165. feedback-neuron enables to feed the output into the same
  166. neuron for further processing. In this version the inputs
  167. consist of any number of patterns. Each time the neuron
  168. is run the oldest input pattern is removed and the neuron
  169. output is added as a new input pattern. The output is
  170. also collected, and all the collections are then returned.
  171.  
  172. The following shows what inputs a neuron gets at each
  173. iteration. Here three input patterns are initially supplied
  174. to the neuron and 5 iterations are produced.
  175.  
  176. 1st iteration
  177.    in1
  178.    in2
  179.    in3
  180.  
  181. 2nd iteration
  182.    in2
  183.    in3
  184.    out1
  185.  
  186. 3rd iteration
  187.    in3
  188.    out1
  189.    out2
  190.  
  191. 4th iteration
  192.    out1
  193.    out2
  194.    out3
  195.  
  196. 5th iteration
  197.    out2
  198.    out3
  199.    out4
  200.  
  201. When finished the following collection of outputs is returned. 
  202. Note that each output is a list, and you may use the output
  203. as input for another oscillating neuron. The ouput can also
  204. used directly to define the sections.
  205.  
  206. --> ((out1) (out2) (out3) (out4))
  207. |#
  208.  
  209. ; Use melody1, melody2, melody3 to define instruments. Redefine
  210. ; neuron rules to get more specific behaviour. The example shows
  211. ; just the basic principles of constructing neurons.
  212.